import math

from baseUtil import bfloats

from baseUtil import convert_value


# 1. 跨越点处导地线风偏计算
# 单位长度风荷载 = calculate_weight_length(导线直径)
# 单位长度风荷载 {新建线路导线在安装（架线）气象条件下（风速为 1Om/s ）的单位长度风压}

def calculate_weight_length(d):
    """
    计算单位长度风荷载 ω4(10)
    :param d: 导线直径 (mm)
    :return: 单位长度风荷载 ω4(10) (N/m)
    """
    # 确保导线直径的单位是毫米
    converted_value, unit = convert_value(d, "导线直径")
  #  print(f"导线直径1 = {converted_value}")
    converted_value, = bfloats(converted_value)
    # 根据导线直径确定风载体形系数K
    if converted_value <= 17:
        K = 1.2
    else:
        K = 1.1
        
    omega4_10 = 0.0613 * K * converted_value
   # print(f"单位长度风荷载 = {omega4_10}")
    return omega4_10


# 中相选定风偏 = calculate_mid_phase_selected_wind_deflection(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径)
def calculate_mid_phase_selected_wind_deflection(omega1, lambda_, l, x, H, d):
    """
    计算中相选定风偏（向上取整）
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越档档距 (m) - 对应参数: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm)
    :return: 中相选定风偏 Zx (m)，向上取整
    """
    
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    omega1, lambda_, l, x, H, d = bfloats(omega1, lambda_, l, x, H, d)
   # print(f"导线直径3 = {d}")
    # 计算单位长度风荷载 - K值在calculate_weight_length内部根据d确定
    omega4_10 = calculate_weight_length(d)
    
    # 计算风偏 Zx
    Zx = omega4_10 * (lambda_ / omega1 + (x * (l - x)) / (2 * H))
   # print(f"中相选定风偏 = {Zx}") 
    # 向上取整
    return math.ceil(Zx)


# 边相选定风偏 = calculate_side_phase_selected_wind_deflection(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径)
def calculate_side_phase_selected_wind_deflection(omega1, lambda_, l, x, H, d):
    """
    计算边相选定风偏（向上取整）
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越档档距 (m) - 对应参数: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm)
    :return: 边相选定风偏 Zx (m)，向上取整
    """
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")    
    d, unit = convert_value(d, "导线直径") 

    omega1, lambda_, l, x, H, d = bfloats(omega1, lambda_, l, x, H, d)
    #print(f"导线直径5 = {d}")
    # 计算单位长度风荷载 - K值在calculate_weight_length内部根据d确定
    omega4_10 = calculate_weight_length(d)
    
    # 计算风偏 Zx
    Zx = omega4_10 * (lambda_ / omega1 + (x * (l - x)) / (2 * H))
    #print(f"边相选定风偏 = {Zx}") 

    # 向上取整
    return math.ceil(Zx)


# 2. 跨越架体宽度计算
# 中相绝缘网选定宽度 = calculate_mid_phase_selected_crossing_width(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径, 跨越架子导线根数)
def calculate_mid_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n):
    """
    计算中相绝缘网选定宽度
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越档档距 (m) - 对应参数: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm)
    :param n: 跨越架子导线根数

    :return: 中相绝缘网选定宽度 B (m)
    """
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")    
    d, unit = convert_value(d, "导线直径") 
    omega1, lambda_, l, x, H, d, n = bfloats(omega1, lambda_, l, x, H, d, n)
    #print(f"导线直径7 = {d}")
    # 计算b值：跨越架子导线根数为1时b=0，绝缘网同时遮护导线地线时b=2.0m
    if n == 1:
        b = 0
    else:
        b = 2.0

    
    # 调用中相选定风偏计算函数获取风偏（向上取整）
    Zx = calculate_mid_phase_selected_wind_deflection(omega1, lambda_, l, x, H, d)
    
    # 计算中相绝缘网选定宽度 B = 2Zx + b
    B = 2 * Zx + b
    #print(f"中相绝缘网选定宽度 = {B}") 
    return round(B, 2)


# 边相绝缘网选定宽度 = calculate_side_phase_selected_crossing_width(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径, 跨越架子导线根数)
def calculate_side_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n):
    """
    计算边相绝缘网选定宽度
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm)
    :param n: 跨越架子导线根数

    :return: 边相绝缘网选定宽度 B (m)
    """
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")    
    d, unit = convert_value(d, "导线直径") 

    omega1, lambda_, l, x, H, d, n = bfloats(omega1, lambda_, l, x, H, d, n)
   # print(f"导线直径9 = {d}")
    # 计算b值：跨越架子导线根数为1时b=0，绝缘网同时遮护导线地线时b=2.0m
    if n == 1:
        b = 0
    else:
        b = 2.0

    # 调用边相选定风偏计算函数获取风偏（向上取整）
    Zx = calculate_side_phase_selected_wind_deflection(omega1, lambda_, l, x, H, d)
    
    # 计算边相绝缘网选定宽度 B = 2Zx + b
    B = 2 * Zx + b
    #print(f"边相绝缘网选定宽度 = {B}") 
    return round(B, 2)

# （中间值）封网总宽度 = calculate_total_net_width(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   跨越架子导线根数               # n
# )
def calculate_total_net_width(voltage_kv, omega1, lambda_, l, x, H, d, n):
    """
    计算封网总宽度
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    n: 跨越架子导线根数
    
    返回:
    total_width: 封网总宽度 (m)
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    voltage_kv, omega1, lambda_, l, x, H, d, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, n)
    
    # 获取边相绝缘网选定宽度
    side_width = calculate_side_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n)
    
    # 判断跨越电压等级
    abs_voltage = abs(voltage_kv)
    
    # 直流电压：1100kV, ±800kV
    if abs_voltage in [1100, +800, -800]:
        total_width = side_width * 2
    
    # 交流电压：750kV, 330kV, 110kV, 35kV
    elif abs_voltage in [750, 330, 110, 35]:
        # 获取中相绝缘网选定宽度
        mid_width = calculate_mid_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n)
        total_width = side_width * 2 + mid_width
    
    else:
        raise ValueError(f"无效的跨越电压等级：{voltage_kv}kV")
    
    return total_width    


# 3. 绝缘绳网长度计算
# 中相绝缘网选定长度 = calculate_mid_phase_selected_net_length(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径, 被跨线路两边线间水平距离, 保护网长度, 交叉跨越角, 跨越架子导线根数)
def calculate_mid_phase_selected_net_length(omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm)
    :param Bk: 被跨线路两边线间水平距离
    :param Lb: 保护网长度 (m)
    :param alpha: 交叉跨越角
    :param n: 跨越架子导线根数
    :return: 中相绝缘网选定长度 Lw (m)
    """
    
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")    
    d, unit = convert_value(d, "导线直径") 
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离") 
    Lb, unit = convert_value(Lb, "保护网长度") 
    omega1, lambda_, l, x, H, d, Bk, Lb, alpha,n = bfloats(omega1, lambda_, l, x, H, d, Bk, Lb, alpha,n)
    #print(f"导线直径11 = {d}")
    # 计算中相绝缘网选定宽度
    B = calculate_mid_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n)

    # 计算封网总长度，公式: Lw = Bk/sinα + B/tanα + 2×Lb
    Lw = (Bk / math.sin(math.radians(alpha))) + (B / math.tan(math.radians(alpha))) + 2 * Lb
    
    return round(Lw, 2)


# 边相绝缘网选定长度 = calculate_side_phase_selected_net_length(跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径, 被跨线路两边线间水平距离, 保护网长度, 交叉跨越角, 跨越架子导线根数)
def calculate_side_phase_selected_net_length(omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    :param omega1: 跨越架单根承索上导线自重力 (N/m)
    :param lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    :param l: 跨越档档距 (m) - 对应参数: 跨越架档距 (m)
    :param x: 跨越物至跨越线路邻近杆塔的水平距离
    :param H: 跨越线路导线水平张力 (N)
    :param d: 导线直径 (mm) - 对应参数: 跨越架承载索直径 (mm)
    :param Bk: 被跨线路两边线间水平距离
    :param Lb: 保护网长度 (m)
    :param alpha: 交叉跨越角
    :param n: 跨越架子导线根数
    :return: 边相绝缘网选定长度 Lw (m)
    """
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")    
    d, unit = convert_value(d, "导线直径") 
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离") 
    Lb, unit = convert_value(Lb, "保护网长度") 
    omega1, lambda_, l, x, H, d, Bk, Lb, alpha,n = bfloats(omega1, lambda_, l, x, H, d, Bk, Lb, alpha,n)
    #print(f"导线直径13 = {d}")
    # 调用边相绝缘网选定宽度计算函数
    B = calculate_side_phase_selected_crossing_width(omega1, lambda_, l, x, H, d, n)

    # 计算封网总长度，公式: Lw = Bk/sinα + B/tanα + 2×Lb
    Lw = (Bk / math.sin(math.radians(alpha))) + (B / math.tan(math.radians(alpha))) + 2 * Lb
 
    return round(Lw, 2)


# 封网总长度 = calculate_total_net_length(跨越电压等级, 跨越架单根承索上导线自重力, 施工线路跨越档两端绝缘子串长度, 跨越架档距, 跨越物至跨越线路邻近杆塔的水平距离, 跨越线路导线水平张力, 导线直径, 被跨线路两边线间水平距离, 保护网长度, 交叉跨越角, 跨越架子导线根数)
def calculate_total_net_length(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    total_length: 封网总长度 (m)
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")

    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 获取边相绝缘网选定长度
    side_length = calculate_side_phase_selected_net_length(omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 判断跨越电压等级
    abs_voltage = abs(voltage_kv)
    
    # 直流电压：1100kV, ±800kV
    if abs_voltage in [1100, +800, -800]:
        total_length = side_length * 2
    
    # 交流电压：750kV, 330kV, 110kV, 35kV
    elif abs_voltage in [750, 330, 110, 35]:
        # 获取中相绝缘网选定长度
        mid_length = calculate_mid_phase_selected_net_length(omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
        total_length = side_length * 2 + mid_length
    
    else:
        raise ValueError(f"无效的跨越电压等级：{voltage_kv}kV")
    
    return math.ceil(total_length)


# 4. 整体临时横梁规格
# 起始桩整体临时横梁规格 = calculate_starting_spec(
#   起始桩临时横梁_钢抱杆中节_数量,      #s_t
#   临时横梁_钢抱杆中节_规格_长度,      # b_l
# )
def calculate_starting_spec(s_t, b_l):
    """
    s_t:起始桩临时横梁_钢抱杆中节_数量
    b_l:临时横梁_钢抱杆中节_规格_长度 (m)
    start_length:起始桩整体临时横梁规格
    """
    b_l, unit = convert_value(b_l, "临时横梁_钢抱杆中节_规格_长度")
    s_t, b_l = bfloats(s_t, b_l)
    start_length = s_t * b_l
    return start_length


# 终止桩整体临时横梁规格 = calculate_ending_spec(
#   终止桩临时横梁_钢抱杆中节_数量,      #d_t
#   临时横梁_钢抱杆中节_规格_长度,      # b_l
# )
def calculate_ending_spec(d_t, b_l):
    """
    d_t:终止桩临时横梁_钢抱杆中节_数量
    b_l:临时横梁_钢抱杆中节_规格_长度 (m)
    end_length:终止桩整体临时横梁规格
    """
    b_l, unit = convert_value(b_l, "临时横梁_钢抱杆中节_规格_长度")
    d_t, b_l = bfloats(d_t, b_l)
    end_length = d_t * b_l
    return end_length


# 5. 临时横梁_钢抱杆中节_数量
# 临时横梁_钢抱杆中节_数量_起始桩 = calculate_starting_pole_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   跨越架子导线根数               # n
# )
def calculate_starting_pole_count(voltage_kv, omega1, lambda_, l, x, H, d, n):
    """
    计算起始桩临时横梁钢抱杆中节数量
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    n: 跨越架子导线根数
    
    返回:
    pole_count: 临时横梁_钢抱杆中节_数量_起始桩
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    voltage_kv, omega1, lambda_, l, x, H, d,n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d,n)
    # 计算封网总宽度
    total_width = calculate_total_net_width(voltage_kv, omega1, lambda_, l, x, H, d, n)
   

    standard_length = 4  # 每节抱杆标准长度(m)
    
    # 计算需要的抱杆数量，向上取整
    pole_count = math.ceil(total_width / standard_length)
    
    return pole_count

# 临时横梁_钢抱杆中节_数量_终止桩 = calculate_ending_pole_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   跨越架子导线根数               # n
# )
def calculate_ending_pole_count(voltage_kv, omega1, lambda_, l, x, H, d, n):
    """
    计算终止桩临时横梁钢抱杆中节数量
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    n: 跨越架子导线根数
    
    返回:
    pole_count: 临时横梁_钢抱杆中节_数量_终止桩
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    voltage_kv, omega1, lambda_, l, x, H, d, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, n)
    # 计算封网总宽度
    total_width = calculate_total_net_width(voltage_kv, omega1, lambda_, l, x, H, d, n)
    
    standard_length = 4  # 每节抱杆标准长度(m)
    
    # 计算需要的抱杆数量，向上取整
    pole_count = math.ceil(total_width / standard_length)
    
    return pole_count

# 临时横梁_钢抱杆中节_总数 = calculate_total_pole_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   跨越架子导线根数               # n
# )
def calculate_total_pole_count(voltage_kv, omega1, lambda_, l, x, H, d, n):
    """
    计算临时横梁钢抱杆中节总数
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    n: 跨越架子导线根数
    
    返回:
    total_count: 临时横梁_钢抱杆中节_总数
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    voltage_kv, omega1, lambda_, l, x, H, d, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, n)
    # 计算起始桩钢抱杆中节数量
    starting_count = calculate_starting_pole_count(voltage_kv, omega1, lambda_, l, x, H, d, n)
    
    # 计算终止桩钢抱杆中节数量
    ending_count = calculate_ending_pole_count(voltage_kv, omega1, lambda_, l, x, H, d, n)
    
    # 计算总数
    total_count = starting_count + ending_count
    
    return total_count


# 6. 地锚埋深计算
# 起始桩_地锚埋深 = calculate_starting_anchor_depth(
#   封网封网封网后张力H2,      # tension
#   跨越架承载索破断力，  # Tb
#   地锚受力方向与地面夹角数据  # alpha
# )
def calculate_starting_anchor_depth(H1, Tb, alpha):
    """
    计算起始桩地锚埋深
    
    参数:
    H1: 封网封网封网后张力H2
    Tb: 跨越架承载索破断力 (kN)
    alpha: 地锚受力方向与地面夹角数据 (度)
    
    返回:
    depth: 起始桩地锚埋深 (m)
    """
  
    H1, unit = convert_value(H1, "封网封网封网后张力H2")
    Tb, unit = convert_value(Tb, "跨越架承载索破断力")

    H1, Tb, alpha = bfloats(H1, Tb, alpha)

    # 初始埋深2.5m
    depth = 2.5
    
    # 计算cos(alpha)
    cos_alpha = math.cos(math.radians(alpha))
    
    # 计算所需的最小力
    required_force = Tb / 3
    
    # 计算实际力
    actual_force = H1 * 0.3 * cos_alpha
    
    # 当实际力小于所需力时，增加埋深
    while actual_force < required_force:
        depth += 0.5
        # 埋深增加会提高实际力
        actual_force = H1 * 0.3 * cos_alpha * (depth / 2.5)
    
    return depth

# 终止桩_地锚埋深 = calculate_ending_anchor_depth(
#   封网后张力,      # tension
#   跨越架承载索破断力,  # Tb
#   地锚受力方向与地面夹角数据  # alpha
# )
def calculate_ending_anchor_depth(H1, Tb, alpha):
    """
    计算终止桩地锚埋深
    
    参数:
    H1: 封网封网封网后张力H2
    Tb: 跨越架承载索破断力 (kN)
    alpha: 地锚受力方向与地面夹角数据 (度)
    
    返回:
    depth: 终止桩地锚埋深 (m)
    """
    H1, unit = convert_value(H1, "封网封网封网后张力H2")
    Tb, unit = convert_value(Tb, "跨越架承载索破断力")
    H1, Tb, alpha = bfloats(H1, Tb, alpha)
    
    # 初始埋深2.5m
    depth = 2.5
    
    # 计算cos(alpha)
    cos_alpha = math.cos(math.radians(alpha))
    
    # 计算所需的最小力
    required_force = Tb / 3
    
    # 计算实际力
    actual_force = H1 * 0.3 * cos_alpha
    
    # 当实际力小于所需力时，增加埋深
    while actual_force < required_force:
        depth += 0.5
        # 埋深增加会提高实际力
        actual_force = H1 * 0.3 * cos_alpha * (depth / 2.5)
    
    return depth


# 地锚埋深 = calculate_anchor_depth(
#   封网后张力,      # tension
#   跨越架承载索破断力,  # Tb
#   地锚受力方向与地面夹角数据  # alpha
# )
def calculate_anchor_depth(H1, Tb, alpha):
    """
    计算终止桩地锚埋深
    
    参数:
    H1: 封网封网封网后张力H2
    Tb: 跨越架承载索破断力 (kN)
    alpha: 地锚受力方向与地面夹角数据 (度)
    
    返回:
    depth: 终止桩地锚埋深 (m)
    """
    H1, unit = convert_value(H1, "封网封网封网后张力H2")
    Tb, unit = convert_value(Tb, "跨越架承载索破断力")
    H1, Tb, alpha = bfloats(H1, Tb, alpha)
    
    # 初始埋深2.5m
    depth = 2.5
    
    # 计算cos(alpha)
    cos_alpha = math.cos(math.radians(alpha))
    
    # 计算所需的最小力
    required_force = Tb / 3
    
    # 计算实际力
    actual_force = H1 * 0.3 * cos_alpha
    
    # 当实际力小于所需力时，增加埋深
    while actual_force < required_force:
        depth += 0.5
        # 埋深增加会提高实际力
        actual_force = H1 * 0.3 * cos_alpha * (depth / 2.5)
    
    return depth

# 7. 展放绝缘绳根数_单侧
#   展放绝缘绳根数_单侧 = calculate_single_side_insulation(
#   展放绝缘绳根数,      #total_count
#   跨越电压等级,      # voltage_kv
# )
def calculate_single_side_insulation(total_count,  voltage_kv):
    """
    计算展放绝缘绳根数_单侧
    total_count:展放绝缘绳根数
    voltage_kv: 跨越电压等级 (kV)
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    total_count, voltage_kv= bfloats(total_count,voltage_kv)
    # 提取电压的绝对值以处理正负情况
    abs_voltage = abs(voltage_kv)
    
    if abs_voltage in [1100, +800, -800]:
        phase_count = 2  # 1100kV, +800kV, -800kV 对应 2 相
    elif abs_voltage in [750, 330, 110, 35]:
        phase_count =  3  # 750kV, 330kV, 110kV, 35kV 对应 3 相
    
    single_side_count = total_count / phase_count

    return single_side_count


# 8. 绝缘网数量计算
# 绝缘网单张数量 = calculate_insulation_net_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   被跨线路两边线间水平距离,      # Bk
#   保护网长度,                  # Lb
#   交叉跨越角,                  # alpha
#   跨越架子导线根数               # n
# )
def calculate_insulation_net_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    计算绝缘网单张数量（向下取整）
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    net_count: 绝缘网单张数量
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")
    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    # 获取封网总长度
    total_length = calculate_total_net_length(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 一张绝缘网的标准长度(m)
    standard_length = 20
    
    # 计算需要的绝缘网数量，向下取整
    net_count = math.floor(total_length / standard_length)
    
    return net_count

# 绝缘网拼接后数量 = calculate_insulation_net_joined_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   被跨线路两边线间水平距离,      # Bk
#   保护网长度,                  # Lb
#   交叉跨越角,                  # alpha
#   跨越架子导线根数               # n
# )
def calculate_insulation_net_joined_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    计算绝缘网拼接后数量（向上取整）
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    joined_count: 绝缘网拼接后数量
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")
    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    # 获取封网总长度
    total_length = calculate_total_net_length(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 一张绝缘网的标准长度(m)
    standard_length = 20
    
    # 计算需要的绝缘网数量，向上取整
    joined_count = math.ceil(total_length / standard_length)
    
    return joined_count


# 9. 绝缘网拼接后长度计算
# 绝缘网拼接后长度 = calculate_insulation_net_joined_length(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   被跨线路两边线间水平距离,      # Bk
#   保护网长度,                  # Lb
#   交叉跨越角,                  # alpha
#   跨越架子导线根数               # n
# )
def calculate_insulation_net_joined_length(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    计算绝缘网拼接后长度
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    joined_length: 绝缘网拼接后长度 (m)
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")
    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    # 获取绝缘网拼接后数量
    joined_count = calculate_insulation_net_joined_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 一张绝缘网的标准长度(m)
    standard_length = 20
    
    # 计算拼接后总长度
    joined_length = joined_count * standard_length
    
    return joined_length


# 10. 绝缘网拼接后边相张数
# 绝缘网拼接后左相张数 = calculate_insulation_net_left_phase_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   被跨线路两边线间水平距离,      # Bk
#   保护网长度,                  # Lb
#   交叉跨越角,                  # alpha
#   跨越架子导线根数               # n
# )
def calculate_insulation_net_left_phase_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    计算绝缘网拼接后左相张数
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    left_phase_count: 绝缘网拼接后左相张数
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")
    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n = bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    # 获取绝缘网拼接后数量
    joined_count = calculate_insulation_net_joined_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 提取电压的绝对值以处理正负情况
    abs_voltage = abs(voltage_kv)
    
    # 判断相数
    if abs_voltage in [1100, +800, -800]:
        phase_count = 2  # 1100kV, +800kV, -800kV 对应 2 相
    elif abs_voltage in [750, 330, 110, 35]:
        phase_count = 3  # 750kV, 330kV, 110kV, 35kV 对应 3 相
    else:
        raise ValueError(f"无效的跨越电压等级：{voltage_kv}kV")
    
    # 计算左相张数
    left_phase_count = joined_count / phase_count
    
    return left_phase_count

# 绝缘网拼接后右相张数 = calculate_insulation_net_right_phase_count(
#   跨越电压等级,                    # voltage_kv
#   跨越架单根承索上导线自重力,      # omega1
#   施工线路跨越档两端绝缘子串长度,   # lambda_
#   跨越架档距,                  # l
#   跨越物至跨越线路邻近杆塔的水平距离, # x
#   跨越线路导线水平张力,          # H
#   导线直径,                    # d
#   被跨线路两边线间水平距离,      # Bk
#   保护网长度,                  # Lb
#   交叉跨越角,                  # alpha
#   跨越架子导线根数               # n
# )
def calculate_insulation_net_right_phase_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n):
    """
    计算绝缘网拼接后右相张数
    
    参数:
    voltage_kv: 跨越电压等级 (kV)
    omega1: 跨越架单根承索上导线自重力 (N/m)
    lambda_: 施工线路跨越档两端绝缘子串长度 (m)
    l: 跨越架档距 (m)
    x: 跨越物至跨越线路邻近杆塔的水平距离
    H: 跨越线路导线水平张力 (N)
    d: 导线直径 (mm)
    Bk: 被跨线路两边线间水平距离
    Lb: 保护网长度 (m)
    alpha: 交叉跨越角
    n: 跨越架子导线根数
    
    返回:
    right_phase_count: 绝缘网拼接后右相张数
    """
    voltage_kv, unit = convert_value(voltage_kv, "跨越电压等级")
    omega1, unit = convert_value(omega1, "跨越架单根承索上导线自重力")
    lambda_, unit = convert_value(lambda_, "施工线路跨越档两端绝缘子串长度")
    l, unit = convert_value(l, "跨越架档距")
    x, unit = convert_value(x, "跨越物至跨越线路邻近杆塔的水平距离")
    H, unit = convert_value(H, "跨越线路导线水平张力")
    d, unit = convert_value(d, "导线直径")
    Bk, unit = convert_value(Bk, "被跨线路两边线间水平距离")
    Lb, unit = convert_value(Lb, "保护网长度")

    voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n =bfloats(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    # 获取绝缘网拼接后数量
    joined_count = calculate_insulation_net_joined_count(voltage_kv, omega1, lambda_, l, x, H, d, Bk, Lb, alpha, n)
    
    # 提取电压的绝对值以处理正负情况
    abs_voltage = abs(voltage_kv)
    
    # 判断相数
    if abs_voltage in [1100, +800, -800]:
        phase_count = 2  # 1100kV, +800kV, -800kV 对应 2 相
    elif abs_voltage in [750, 330, 110, 35]:
        phase_count = 3  # 750kV, 330kV, 110kV, 35kV 对应 3 相
    else:
        raise ValueError(f"无效的跨越电压等级：{voltage_kv}kV")
    
    # 计算右相张数
    right_phase_count = joined_count / phase_count
    
    return right_phase_count


# 11. 实际张力和实际安全系数
#牵引绳索_强力丝_10_实际张力 = calculate_tension_and_horizontal_q10_force(
#   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ10 强力丝初始挂点张力                   #T_0_q10
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
# )

def calculate_tension_and_horizontal_q10_force(h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1):
    """
    计算张力和水平张力，基于以下公式：
    公式 3: T_n = T_(n-1) + (omega2 * h_(n-1)) / cos(phi_(n-1))
    公式 5: H = { -[(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)] *sqrt{ [(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)]^2 - 4 * [8 * l * cos(tan^-1(|h|/l))] + [2 * |h| * sin(2 * tan^-1(|h|/l)) * (l^3 * omega^3)] } } / { 2 * [8 * l * cos(tan^-1(|h|/l))] + 2 * |h| * sin(2 * tan^-1(|h|/l)) }

    参数：
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0: φ10 强力丝初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)

    返回：
    T_1, T_2, H: 张力 T_1, 张力 T_2, 水平张力 H (kN)  
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_q10, unit = convert_value(T_0_q10, "φ10 强力丝初始挂点张力")

    h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1 = bfloats(h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1)
    
    # 公式 3：T_1 = T_0 + (omega * h_0) / cos(phi_0) （n=1）
    T_1 = T_0_q10 + (omega2 * h_0) / math.cos(math.radians(phi_0))

    # 公式 3：T_2 = T_1 + (omega * h_1) / cos(phi_1) （n=2）
    T_2 = T_1 + (omega2 * h_1) / math.cos(math.radians(phi_1))

    # 公式 5：H = (term1 + sqrt(term2 - term3 + term4)) / denominator
    h = abs(h_0)
    tan_inverse = math.atan(h / l)
    cos_tan_inverse = math.cos(tan_inverse)
    sin_2_tan_inverse = math.sin(2 * tan_inverse)

    term1 = ((-4) * l * cos_tan_inverse * (T_1 + T_2))  # 正值
    term2 = term1 ** 2
    term3 = 4 * (8 * l * cos_tan_inverse)
    term4 = 2 * h * sin_2_tan_inverse * (l ** 3 * omega2 ** 2)
    term5 = math.sqrt(term2 - term3 + term4)
    numerator = (- term1) + term5

    denominator = 2 * (8 * l * cos_tan_inverse) + 2 * h * sin_2_tan_inverse

    q10_H = numerator / denominator

    return q10_H


#牵引绳索_强力丝_10_实际安全系数 = calculate_safety_factor_q10(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ10 强力丝初始挂点张力                   #T_0_q10
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
#   牵引绳索_强力丝_10_破断拉力   #breaking_force_q10
# )
def calculate_safety_factor_q10(h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1, breaking_force_q10):
    """
    计算牵引绳索_强力丝_18_实际安全系数
    
    参数:
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_q10: φ10 强力丝初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)
    breaking_force_q10: 牵引绳索_强力丝_10_破断拉力

    返回:
    safety_factor: 安全系数
    """
    
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_q10, unit = convert_value(T_0_q10, "φ10 强力丝初始挂点张力")
    breaking_force_q10, unit = convert_value(breaking_force_q10, "牵引绳索_强力丝_18_破断拉力")
    h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1, breaking_force_q10 = bfloats(h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1, breaking_force_q10)
 
    # 计算强力丝实际安全系数
    actual_tension = calculate_tension_and_horizontal_q18_force(h_0, h_1, l, omega2, T_0_q10, phi_0, phi_1)
    
    # 计算安全系数
    safety_factor_q10 = breaking_force_q10 / actual_tension

    return safety_factor_q10


#牵引绳索_强力丝_18_实际张力= calculate_tension_and_horizontal_q18_force(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ18 强力丝初始挂点张力                   #T_0_q18
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
# )
def calculate_tension_and_horizontal_q18_force(h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1):
    """
    计算张力和水平张力，基于以下公式：
    公式 3: T_n = T_(n-1) + (omega2 * h_(n-1)) / cos(phi_(n-1))
    公式 5: H = { -[(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)] *sqrt{ [(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)]^2 - 4 * [8 * l * cos(tan^-1(|h|/l))] + [2 * |h| * sin(2 * tan^-1(|h|/l)) * (l^3 * omega^3)] } } / { 2 * [8 * l * cos(tan^-1(|h|/l))] + 2 * |h| * sin(2 * tan^-1(|h|/l)) }

    参数：
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_q18: φ18 强力丝初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)

    返回：
    T_1, T_2, H: 张力 T_1, 张力 T_2, 水平张力 H (N)  
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_q18, unit = convert_value(T_0_q18, "φ10 强力丝初始挂点张力")
    h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1 = bfloats(h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1)
    
    # 公式 3：T_1 = T_0 + (omega * h_0) / cos(phi_0) （n=1）
    T_1 = T_0_q18 + (omega2 * h_0) / math.cos(math.radians(phi_0))

    # 公式 3：T_2 = T_1 + (omega * h_1) / cos(phi_1) （n=2）
    T_2 = T_1 + (omega2 * h_1) / math.cos(math.radians(phi_1))

    # 公式 5：H = (term1 + sqrt(term2 - term3 + term4)) / denominator
    h = abs(h_0)
    tan_inverse = math.atan(h / l)
    cos_tan_inverse = math.cos(tan_inverse)
    sin_2_tan_inverse = math.sin(2 * tan_inverse)

    term1 = ((-4) * l * cos_tan_inverse * (T_1 + T_2))  # 正值
    term2 = term1 ** 2
    term3 = 4 * (8 * l * cos_tan_inverse)
    term4 = 2 * h * sin_2_tan_inverse * (l ** 3 * omega2 ** 2)
    term5 = math.sqrt(term2 - term3 + term4)
    numerator = (- term1) + term5

    denominator = 2 * (8 * l * cos_tan_inverse) + 2 * h * sin_2_tan_inverse

    q18_H = numerator / denominator

    return q18_H


#牵引绳索_强力丝_18_实际安全系数= calculate_safety_factor_q18(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ18 强力丝初始挂点张力                   #T_0_q18
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
#   牵引绳索_强力丝_18_破断拉力    #breaking_force_q18
# )
def calculate_safety_factor_q18(h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1, breaking_force_q18):
    """
    计算牵引绳索_强力丝_18_实际安全系数
    
    参数:
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_q18: φ18 强力丝初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)
    breaking_force_q18: 牵引绳索_强力丝_18_破断拉力

    返回:
    safety_factor: 安全系数
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_q18, unit = convert_value(T_0_q18, "φ10 强力丝初始挂点张力") 
    breaking_force_q18, unit = convert_value(breaking_force_q18, "牵引绳索_强力丝_18_破断拉力") 
    h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1,breaking_force_q18 = bfloats(h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1, breaking_force_q18)
    # 计算强力丝实际安全系数
    actual_tension = calculate_tension_and_horizontal_q18_force(h_0, h_1, l, omega2, T_0_q18, phi_0, phi_1)
    
    # 计算安全系数
    safety_factor_q18 = breaking_force_q18 / actual_tension

    return safety_factor_q18

#牵引绳索_导引绳_13_实际张力 = calculate_tension_and_horizontal_d13_force(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ13 导引绳初始挂点张力                   #T_0_d13
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
# )
def calculate_tension_and_horizontal_d13_force(h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1):
    """
    计算张力和水平张力，基于以下公式：
    公式 3: T_n = T_(n-1) + (omega2 * h_(n-1)) / cos(phi_(n-1))
    公式 5: H = { -[(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)] *sqrt{ [(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)]^2 - 4 * [8 * l * cos(tan^-1(|h|/l))] + [2 * |h| * sin(2 * tan^-1(|h|/l)) * (l^3 * omega^3)] } } / { 2 * [8 * l * cos(tan^-1(|h|/l))] + 2 * |h| * sin(2 * tan^-1(|h|/l)) }

    参数：
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_q13: φ13 导引绳初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)

    返回：
    T_1, T_2, H: 张力 T_1, 张力 T_2, 水平张力 H (N)  
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d13, unit = convert_value(T_0_d13, "φ13 导引绳初始挂点张力") 
    h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1 = bfloats(h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1)
    # 公式 3：T_1 = T_0 + (omega * h_0) / cos(phi_0) （n=1）
    T_1 = T_0_d13 + (omega2 * h_0) / math.cos(math.radians(phi_0))

    # 公式 3：T_2 = T_1 + (omega * h_1) / cos(phi_1) （n=2）
    T_2 = T_1 + (omega2 * h_1) / math.cos(math.radians(phi_1))

    # 公式 5：H = (term1 + sqrt(term2 - term3 + term4)) / denominator
    h = abs(h_0)
    tan_inverse = math.atan(h / l)
    cos_tan_inverse = math.cos(tan_inverse)
    sin_2_tan_inverse = math.sin(2 * tan_inverse)

    term1 = ((-4) * l * cos_tan_inverse * (T_1 + T_2))  # 正值
    term2 = term1 ** 2
    term3 = 4 * (8 * l * cos_tan_inverse)
    term4 = 2 * h * sin_2_tan_inverse * (l ** 3 * omega2 ** 2)
    term5 = math.sqrt(term2 - term3 + term4)
    numerator = (- term1) + term5

    denominator = 2 * (8 * l * cos_tan_inverse) + 2 * h * sin_2_tan_inverse

    d13_H = numerator / denominator

    return d13_H

#牵引绳索_导引绳_13_实际安全系数 = calculate_safety_factor_d13(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ13 导引绳初始挂点张力                   #T_0_d13
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
#  牵引绳索_导引绳_13_破断拉力    #breaking_force_d13
# )
def calculate_safety_factor_d13(h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1, breaking_force_d13):
    """
    计算牵引绳索_导引绳_13_实际安全系数
    
    参数:
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_q13: φ13 导引绳初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)
    breaking_force_d13: 牵引绳索_导引绳_13_破断拉力

    返回:
    safety_factor: 安全系数
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d13, unit = convert_value(T_0_d13, "φ13 导引绳初始挂点张力") 
    breaking_force_d13,unit = convert_value(breaking_force_d13, "牵引绳索_导引绳_13_破断拉力") 
    h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1, breaking_force_d13 = bfloats(h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1, breaking_force_d13)
    
    # 计算导引绳实际安全系数
    actual_tension = calculate_tension_and_horizontal_d13_force(h_0, h_1, l, omega2, T_0_d13, phi_0, phi_1)
    
    # 计算安全系数
    safety_factor_d13 = breaking_force_d13 / actual_tension

    return safety_factor_d13

#牵引绳索_导引绳_18_实际张力 = calculate_tension_and_horizontal_d18_force(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#    φ18 导引绳初始挂点张力                   #T_0_d18
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
# )
def calculate_tension_and_horizontal_d18_force(h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1):
    """
    计算张力和水平张力，基于以下公式：
    公式 3: T_n = T_(n-1) + (omega2 * h_(n-1)) / cos(phi_(n-1))
    公式 5: H = { -[(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)] *sqrt{ [(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)]^2 - 4 * [8 * l * cos(tan^-1(|h|/l))] + [2 * |h| * sin(2 * tan^-1(|h|/l)) * (l^3 * omega^3)] } } / { 2 * [8 * l * cos(tan^-1(|h|/l))] + 2 * |h| * sin(2 * tan^-1(|h|/l)) }

    参数：
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_d18: φ18 导引绳初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)

    返回：
    T_1, T_2, H: 张力 T_1, 张力 T_2, 水平张力 H (N)  
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d18, unit = convert_value(T_0_d18, "φ13 导引绳初始挂点张力") 
    h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1 =bfloats(h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1)
    # 公式 3：T_1 = T_0 + (omega * h_0) / cos(phi_0) （n=1）
    T_1 = T_0_d18 + (omega2 * h_0) / math.cos(math.radians(phi_0))

    # 公式 3：T_2 = T_1 + (omega * h_1) / cos(phi_1) （n=2）
    T_2 = T_1 + (omega2 * h_1) / math.cos(math.radians(phi_1))

    # 公式 5：H = (term1 + sqrt(term2 - term3 + term4)) / denominator
    h = abs(h_0)
    tan_inverse = math.atan(h / l)
    cos_tan_inverse = math.cos(tan_inverse)
    sin_2_tan_inverse = math.sin(2 * tan_inverse)

    term1 = ((-4) * l * cos_tan_inverse * (T_1 + T_2))  # 正值
    term2 = term1 ** 2
    term3 = 4 * (8 * l * cos_tan_inverse)
    term4 = 2 * h * sin_2_tan_inverse * (l ** 3 * omega2 ** 2)
    term5 = math.sqrt(term2 - term3 + term4)
    numerator = (- term1) + term5

    denominator = 2 * (8 * l * cos_tan_inverse) + 2 * h * sin_2_tan_inverse

    d18_H = numerator / denominator

    return d18_H

#牵引绳索_导引绳_18_实际安全系数 = calculate_safety_factor_d18(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#   φ18 导引绳初始挂点张力                   #T_0_d18
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
#  牵引绳索_导引绳_18_破断拉力   #breaking_force_d18
# )
def calculate_safety_factor_d18(h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1, breaking_force_d18):
    """
    计算牵引绳索_导引绳_18_实际安全系数
    
    参数:
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_d18: φ18 导引绳初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)
    breaking_force_d18: 牵引绳索_导引绳_18_破断拉力

    返回:
    safety_factor: 安全系数
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d18, unit = convert_value(T_0_d18, "φ18 导引绳初始挂点张力") 
    breaking_force_d18,unit = convert_value(breaking_force_d18, "牵引绳索_导引绳_18_破断拉力") 
    h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1, breaking_force_d18 = bfloats(h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1, breaking_force_d18)
    # 计算导引绳实际安全系数
    actual_tension = calculate_tension_and_horizontal_d18_force(h_0, h_1, l, omega2, T_0_d18, phi_0, phi_1)
    
    # 计算安全系数
    safety_factor_d18 = breaking_force_d18 / actual_tension

    return safety_factor_d18

#牵引绳索_牵引绳_28_实际张力 = calculate_tension_and_horizontal_qy28_force(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#    φ28 牵引绳初始挂点张力                   #T_0_d28
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
# )
def calculate_tension_and_horizontal_qy28_force(h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1):
    """
    计算张力和水平张力，基于以下公式：
    公式 3: T_n = T_(n-1) + (omega2 * h_(n-1)) / cos(phi_(n-1))
    公式 5: H = { -[(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)] *sqrt{ [(-4) * l * cos(tan^-1(|h|/l)) * (T_1 + T_2)]^2 - 4 * [8 * l * cos(tan^-1(|h|/l))] + [2 * |h| * sin(2 * tan^-1(|h|/l)) * (l^3 * omega^3)] } } / { 2 * [8 * l * cos(tan^-1(|h|/l))] + 2 * |h| * sin(2 * tan^-1(|h|/l)) }

    参数：
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_d28: φ28 牵引绳初始挂点张力 (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)

    返回：
    T_1, T_2, H: 张力 T_1, 张力 T_2, 水平张力 H (N)  
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d28, unit = convert_value(T_0_d28, "φ28 牵引绳初始挂点张力") 
    h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1 = bfloats(h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1)
    # 公式 3：T_1 = T_0 + (omega * h_0) / cos(phi_0) （n=1）
    T_1 = T_0_d28 + (omega2 * h_0) / math.cos(math.radians(phi_0))

    # 公式 3：T_2 = T_1 + (omega * h_1) / cos(phi_1) （n=2）
    T_2 = T_1 + (omega2 * h_1) / math.cos(math.radians(phi_1))

    # 公式 5：H = (term1 + sqrt(term2 - term3 + term4)) / denominator
    h = abs(h_0)
    tan_inverse = math.atan(h / l)
    cos_tan_inverse = math.cos(tan_inverse)
    sin_2_tan_inverse = math.sin(2 * tan_inverse)

    term1 = ((-4) * l * cos_tan_inverse * (T_1 + T_2))  # 正值
    term2 = term1 ** 2
    term3 = 4 * (8 * l * cos_tan_inverse)
    term4 = 2 * h * sin_2_tan_inverse * (l ** 3 * omega2 ** 2)
    term5 = math.sqrt(term2 - term3 + term4)
    numerator = (- term1) + term5

    denominator = 2 * (8 * l * cos_tan_inverse) + 2 * h * sin_2_tan_inverse

    qy28_H = numerator / denominator

    return qy28_H

#牵引绳索_牵引绳_28_实际安全系数= calculate_safety_factor_qy28(
##   与领塔悬挂点的高差，            # h_0
#   与领塔悬挂点的高差            #h_1
#   线档档距,                  # l
#    架空线单位长度自重力           #omega2
#  φ28 牵引绳初始挂点张力 (kg)                 #T_0_d28
#   初始两相邻线档的悬挂点高差角     #phi_0
#   初始两相邻线档的悬挂点高差角   #phi_1
#  牵引绳索_牵引绳_28_破断拉力   #breaking_force_qy28
# )
def calculate_safety_factor_qy28(h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1, breaking_force_qy28):
    """
    计算牵引绳索_牵引绳_28_实际安全系数
    
    参数:
    h_0: 与领塔悬挂点的高差 h_0 (m)   --用于计算 T_1
    h_1: 与领塔悬挂点的高差 h_1 (m)   --用于计算 T_2
    l: 线档的档距 (m)
    omega2: 架空线单位长度自重力 (kg/m)
    T_0_d28: φ28 牵引绳初始挂点张力  (kg)
    phi_0: 初始两相邻线档的悬挂点高差角(°)
    phi_1: 初始两相邻线档的悬挂点高差角(°)
    breaking_force_qy28: 牵引绳索_牵引绳_28_破断拉力

    返回:
    safety_factor: 安全系数
    """
    h_0, unit = convert_value(h_0, "与领塔悬挂点的高差")
    h_1, unit = convert_value(h_1, "与领塔悬挂点的高差")
    l, unit = convert_value(l, "线档档距")
    omega2, unit = convert_value(omega2, "架空线单位长度自重力")
    T_0_d28, unit = convert_value(T_0_d28, "φ28 牵引绳初始挂点张力") 
    breaking_force_qy28, unit = convert_value(breaking_force_qy28, "牵引绳索_牵引绳_28_破断拉力") 
    h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1, breaking_force_qy28 = bfloats(h_0, h_1, l, omega2, T_0_d28, phi_0, phi_1, breaking_force_qy28)

    # 计算牵引绳实际安全系数
    actual_tension = calculate_tension_and_horizontal_qy28_force(h_0, h_1, l, omega2,T_0_d28 , phi_0, phi_1)
    
    # 计算安全系数
    safety_factor_qy28 = breaking_force_qy28 / actual_tension

    return safety_factor_qy28


'''
# 施工方案计算
'''
def sgfa_calculate(d: dict):
    res_dict = {} 
    
    # 1. 绝缘绳网长度计算
    try:
        res_dict['封网总长度'] = str(round(calculate_total_net_length(res_dict['跨越电压等级'], res_dict['跨越架单根承索上导线自重力'], res_dict['施工线路跨越档两端绝缘子串长度'], res_dict['跨越架档距'], res_dict['跨越物至跨越线路邻近杆塔的水平距离'], res_dict['跨越线路导线水平张力'], res_dict['导线直径'], res_dict['被跨线路两边线间水平距离'], res_dict['保护网长度'], res_dict['交叉跨越角'], res_dict['跨越架子导线根数']), 2)) + " m"
    except Exception as e:
        print(e)
   
    # 2. 整体临时横梁规格
    try:
        res_dict['起始桩整体临时横梁规格'] = round(calculate_starting_spec(
            res_dict['起始桩临时横梁_钢抱杆中节_数量'],      #s_t
            res_dict['临时横梁_钢抱杆中节_规格_长度'],      # b_l
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['终止桩整体临时横梁规格'] = round(calculate_ending_spec(
            res_dict['终止桩临时横梁_钢抱杆中节_数量'],      #d_t
            res_dict['临时横梁_钢抱杆中节_规格_长度'],      # b_l
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['临时横梁_钢抱杆中节_数量_起始桩'] = round(calculate_starting_pole_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['临时横梁_钢抱杆中节_数量_终止桩'] = round(calculate_ending_pole_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['临时横梁_钢抱杆中节_总数'] = round(calculate_total_pole_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    # 3. 地锚埋深计算
    try:
        res_dict['起始桩_地锚埋深'] = str(round(calculate_starting_anchor_depth(
            res_dict['封网封网封网后张力H2'],      # tension
            res_dict['跨越架承载索破断力'],      # Tb
            res_dict['地锚受力方向与地面夹角数据']      # alpha
        ), 2)) + " m"
    except Exception as e:
        print(e)

    try:
        res_dict['终止桩_地锚埋深'] = str(round(calculate_ending_anchor_depth(
            res_dict['封网后张力'],      # tension
            res_dict['跨越架承载索破断力'],      # Tb
            res_dict['地锚受力方向与地面夹角数据']      # alpha
        ), 2)) + " m"
    except Exception as e:
        print(e)

    try:
        res_dict['终止桩_地锚埋深'] = str(round(calculate_anchor_depth(
            res_dict['封网后张力'],      # tension
            res_dict['跨越架承载索破断力'],      # Tb
            res_dict['地锚受力方向与地面夹角数据']      # alpha
        ), 2)) + " m"
    except Exception as e:
        print(e)

    # 4. 展放绝缘绳根数_单侧计算
    try:
        res_dict['展放绝缘绳根数_单侧'] = round(calculate_single_side_insulation(
            res_dict['展放绝缘绳根数'],      # total_count
            res_dict['跨越电压等级,'],      # voltage_kv
        ), 2)
    except Exception as e:
        print(e)

    # 5. 绝缘网数量计算
    try:
        res_dict['绝缘网单张数量'] = round(calculate_insulation_net_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['被跨线路两边线间水平距离'],      # Bk 
            res_dict['保护网长度'],                  # Lb
            res_dict['交叉跨越角'],                  # alpha
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['绝缘网拼接后数量'] = round(calculate_insulation_net_joined_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['被跨线路两边线间水平距离'],      # Bk 
            res_dict['保护网长度'],                  # Lb
            res_dict['交叉跨越角'],                  # alpha
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    # 6. 绝缘网拼接后长度计算
    try:
        res_dict['绝缘网拼接后长度'] = str(round(calculate_insulation_net_joined_length(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['被跨线路两边线间水平距离'],      # Bk 
            res_dict['保护网长度'],                  # Lb
            res_dict['交叉跨越角'],                  # alpha
            res_dict['跨越架子导线根数']               # n
        ), 2)) + " m"
    except Exception as e:
        print(e)

    # 7. 绝缘网拼接后边相张数
    try:
        res_dict['绝缘网拼接后左相张数'] = round(calculate_insulation_net_left_phase_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['被跨线路两边线间水平距离'],      # Bk 
            res_dict['保护网长度'],                  # Lb
            res_dict['交叉跨越角'],                  # alpha
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['绝缘网拼接后右相张数'] = round(calculate_insulation_net_right_phase_count(
            res_dict['跨越电压等级'],      #voltage_kv
            res_dict['跨越架单根承索上导线自重力'],      # omega1
            res_dict['施工线路跨越档两端绝缘子串长度'],   # lambda_
            res_dict['跨越架档距'],                  # l
            res_dict['跨越物至跨越线路邻近杆塔的水平距离'], # x
            res_dict['跨越线路导线水平张力'],          # H
            res_dict['导线直径'],                    # d
            res_dict['被跨线路两边线间水平距离'],      # Bk 
            res_dict['保护网长度'],                  # Lb
            res_dict['交叉跨越角'],                  # alpha
            res_dict['跨越架子导线根数']               # n
        ), 2)
    except Exception as e:
        print(e)

    # 8. 实际张力和实际安全系数
    try:
        res_dict['牵引绳索_强力丝_10_实际张力'] = str(round(calculate_tension_and_horizontal_q10_force(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['初始挂点张力'],                   # T_0
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
        ), 2)) + " kN"
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_强力丝_10_实际安全系数'] = round(calculate_safety_factor_q10(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ10 强力丝初始挂点张力'],                   # T_0_q10
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
            res_dict['牵引绳索_强力丝_10_破断拉力'],           # breaking_force_q10
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_强力丝_18_实际张力'] = str(round(calculate_tension_and_horizontal_q18_force(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ18 强力丝初始挂点张力'],                   # T_0_q18
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
        ), 2)) + " kN"
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_强力丝_18_实际安全系数'] = round(calculate_safety_factor_q18(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ18 强力丝初始挂点张力'],                   # T_0_q18
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
            res_dict['牵引绳索_强力丝_18_破断拉力'],           # breaking_force_q18
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_导引绳_13_实际张力'] = str(round(calculate_tension_and_horizontal_d13_force(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ13 导引绳初始挂点张力'],                   #T_0_d13
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
        ), 2)) + " kN"
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_导引绳_13_实际安全系数'] = round(calculate_safety_factor_d13(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ13 导引绳初始挂点张力'],                   # T_0_d13
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
            res_dict['牵引绳索_导引绳_13_破断拉力'],           # breaking_force_d13
        ), 2)
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_导引绳_18_实际张力'] = str(round(calculate_tension_and_horizontal_d18_force(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ18 导引绳初始挂点张力'],                   #T_0_d18
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
        ), 2)) + " kN"
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_导引绳_18_实际安全系数'] = round(calculate_safety_factor_d18(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ18 导引绳初始挂点张力'],                   # T_0_d18
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
            res_dict['牵引绳索_导引绳_18_破断拉力'],           # breaking_force_d18
        ), 2)
    except Exception as e:
        print(e)       

    try:
        res_dict['牵引绳索_牵引绳_28_实际张力'] = str(round(calculate_tension_and_horizontal_qy28_force(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ28 牵引绳初始挂点张力'],                   #T_0_d28
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
        ), 2)) + " kN"
    except Exception as e:
        print(e)

    try:
        res_dict['牵引绳索_牵引绳_28_实际安全系数='] = round(calculate_safety_factor_qy28(
            res_dict['与领塔悬挂点的高差'],      # h_0
            res_dict['与领塔悬挂点的高差'],      # h_1
            res_dict['线档档距'],                  # l
            res_dict['架空线单位长度自重力'],           # omega2
            res_dict['φ28 牵引绳初始挂点张力'],                   # T_0_d28
            res_dict['初始两相邻线档的悬挂点高差角'],          # phi_0
            res_dict['初始两相邻线档的悬挂点高差角'],           # phi_1
            res_dict['牵引绳索_牵引绳_28_破断拉力'],           # breaking_force_qy28
        ), 2)
    except Exception as e:
        print(e)   

    return res_dict
